From cfeabbc21bd0218818c5bc853543c76e499ada0c Mon Sep 17 00:00:00 2001 From: Yehuda Katz Date: Mon, 19 May 2014 22:40:50 -0700 Subject: [PATCH] Update to Rust master --- libs/hammer.rs | 2 +- libs/rust-toml | 2 +- src/bin/cargo-compile.rs | 2 +- src/bin/cargo-read-manifest.rs | 2 +- src/bin/cargo-verify-project.rs | 2 +- src/bin/cargo.rs | 4 +- src/cargo/core/dependency.rs | 2 +- src/cargo/core/errors.rs | 16 +++--- src/cargo/core/manifest.rs | 62 +++++++++++----------- src/cargo/core/namever.rs | 12 ++--- src/cargo/core/package.rs | 4 +- src/cargo/core/version_req.rs | 22 ++++---- src/cargo/lib.rs | 8 ++- src/cargo/ops/cargo_compile.rs | 2 +- src/cargo/ops/cargo_rustc.rs | 20 +++---- src/cargo/sources/path.rs | 2 +- src/cargo/util/config.rs | 34 ++++++------ src/cargo/util/process_builder.rs | 87 ++++++++++++++----------------- src/cargo/util/result.rs | 12 ++--- 19 files changed, 145 insertions(+), 152 deletions(-) diff --git a/libs/hammer.rs b/libs/hammer.rs index da5c02546..c305bcb84 160000 --- a/libs/hammer.rs +++ b/libs/hammer.rs @@ -1 +1 @@ -Subproject commit da5c02546229eee6fb4305255333515bf8954fdd +Subproject commit c305bcb84ed51d7bd808bc20c09c00a1beb1b087 diff --git a/libs/rust-toml b/libs/rust-toml index a0f63ba56..0de103ed1 160000 --- a/libs/rust-toml +++ b/libs/rust-toml @@ -1 +1 @@ -Subproject commit a0f63ba56099404b4ac1db513ad4d4ffd2d1a7c3 +Subproject commit 0de103ed19997884f2766456f7a003b94f1daa42 diff --git a/src/bin/cargo-compile.rs b/src/bin/cargo-compile.rs index 269ec346b..208b15792 100644 --- a/src/bin/cargo-compile.rs +++ b/src/bin/cargo-compile.rs @@ -14,7 +14,7 @@ use std::os; #[deriving(Eq,Clone,Decodable,Encodable)] pub struct Options { - manifest_path: Option<~str> + manifest_path: Option } impl FlagConfig for Options {} diff --git a/src/bin/cargo-read-manifest.rs b/src/bin/cargo-read-manifest.rs index 7aeaa4e42..01c11dfdf 100644 --- a/src/bin/cargo-read-manifest.rs +++ b/src/bin/cargo-read-manifest.rs @@ -12,7 +12,7 @@ use cargo::ops::cargo_read_manifest::read_manifest; #[deriving(Eq,Clone,Decodable)] struct Options { - manifest_path: ~str + manifest_path: StrBuf } impl FlagConfig for Options {} diff --git a/src/bin/cargo-verify-project.rs b/src/bin/cargo-verify-project.rs index d6fe21056..512ecc751 100644 --- a/src/bin/cargo-verify-project.rs +++ b/src/bin/cargo-verify-project.rs @@ -12,7 +12,7 @@ use getopts::{reqopt,getopts}; */ fn main() { - let arguments = args(); + let arguments: Vec = args().iter().map(|a| a.to_strbuf()).collect(); let opts = ~[ reqopt("m", "manifest", "the location of the manifest", "MANIFEST") diff --git a/src/bin/cargo.rs b/src/bin/cargo.rs index 8c9cb52e1..d2e1c46e8 100644 --- a/src/bin/cargo.rs +++ b/src/bin/cargo.rs @@ -47,12 +47,12 @@ fn process(mut args: Vec<~str>) -> CLIResult<(~str, Vec<~str>)> { #[deriving(Encodable)] struct ConfigOut { - values: collections::HashMap<~str, config::ConfigValue> + values: collections::HashMap } #[deriving(Decodable)] struct ConfigForKeyFlags { - key: ~str, + key: StrBuf, human: bool } diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs index fcffed66d..c2ec45890 100644 --- a/src/cargo/core/dependency.rs +++ b/src/cargo/core/dependency.rs @@ -1,5 +1,5 @@ use semver::Version; -use core::{NameVer,VersionReq}; +use core::{VersionReq}; use util::CargoResult; #[deriving(Eq,Clone,Show)] diff --git a/src/cargo/core/errors.rs b/src/cargo/core/errors.rs index 2f8517f26..a0c8ffe15 100644 --- a/src/cargo/core/errors.rs +++ b/src/cargo/core/errors.rs @@ -17,8 +17,8 @@ pub enum CargoError { impl Show for CargoError { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - &CargoInternalError(ref err) => write!(f.buf, "{}", err), - &CargoCLIError(ref err) => write!(f.buf, "{}", err) + &CargoInternalError(ref err) => write!(f, "{}", err), + &CargoCLIError(ref err) => write!(f, "{}", err) } } } @@ -37,7 +37,7 @@ impl CLIError { impl Show for CLIError { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "{}", self.msg) + write!(f, "{}", self.msg) } } @@ -54,18 +54,18 @@ impl Show for InternalError { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { &StringConversionError(ref string, ref type_name) => { - write!(f.buf, "Couldn't convert `{}` into {}", string, type_name) + write!(f, "Couldn't convert `{}` into {}", string, type_name) }, &MissingManifest(ref path, ref file) => { - write!(f.buf, "Couldn't find a {} in the project (`{}` or any parent directory", file, path.display()) + write!(f, "Couldn't find a {} in the project (`{}` or any parent directory", file, path.display()) }, &WrappedIoError(ref io_error) => { - write!(f.buf, "{}", io_error) + write!(f, "{}", io_error) }, &PathError(ref s) | &Described(ref s) => { - write!(f.buf, "{}", s) + write!(f, "{}", s) }, - &Other => write!(f.buf, "Other internal error") + &Other => write!(f, "Other internal error") } } } diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs index 159483fc2..d94c86c65 100644 --- a/src/cargo/core/manifest.rs +++ b/src/cargo/core/manifest.rs @@ -15,36 +15,36 @@ use util::CargoResult; #[deriving(Eq,Clone)] pub struct Manifest { summary: Summary, - authors: Vec<~str>, + authors: Vec, targets: Vec, target_dir: Path, } impl Show for Manifest { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "Manifest({}, authors={}, targets={}, target_dir={})", self.summary, self.authors, self.targets, self.target_dir.display()) + write!(f, "Manifest({}, authors={}, targets={}, target_dir={})", self.summary, self.authors, self.targets, self.target_dir.display()) } } #[deriving(Eq,Clone,Encodable)] pub struct SerializedManifest { - name: ~str, - version: ~str, + name: StrBuf, + version: StrBuf, dependencies: Vec, - authors: Vec<~str>, + authors: Vec, targets: Vec, - target_dir: ~str + target_dir: StrBuf } impl> Encodable for Manifest { fn encode(&self, s: &mut S) -> Result<(), E> { SerializedManifest { - name: self.summary.get_name().to_owned(), - version: self.summary.get_version().to_str(), + name: self.summary.get_name().to_strbuf(), + version: format_strbuf!("{}", self.summary.get_version()), dependencies: self.summary.get_dependencies().iter().map(|d| SerializedDependency::from_dependency(d)).collect(), authors: self.authors.clone(), targets: self.targets.clone(), - target_dir: self.target_dir.as_str().unwrap().to_owned() + target_dir: self.target_dir.as_str().unwrap().to_strbuf() }.encode(s) } } @@ -58,15 +58,15 @@ pub enum TargetKind { #[deriving(Clone,Eq)] pub struct Target { kind: TargetKind, - name: ~str, + name: StrBuf, path: Path } #[deriving(Encodable)] pub struct SerializedTarget { kind: &'static str, - name: ~str, - path: ~str + name: StrBuf, + path: StrBuf } impl> Encodable for Target { @@ -79,14 +79,14 @@ impl> Encodable for Target { SerializedTarget { kind: kind, name: self.name.clone(), - path: self.path.as_str().unwrap().to_owned() + path: self.path.as_str().unwrap().to_strbuf() }.encode(s) } } impl Show for Target { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "{}(name={}, path={})", self.kind, self.name, self.path.display()) + write!(f, "{}(name={}, path={})", self.kind, self.name, self.path.display()) } } @@ -112,7 +112,7 @@ impl Manifest { self.get_summary().get_name_ver().get_version() } - pub fn get_authors<'a>(&'a self) -> &'a [~str] { + pub fn get_authors<'a>(&'a self) -> &'a [StrBuf] { self.authors.as_slice() } @@ -133,7 +133,7 @@ impl Target { pub fn lib_target(name: &str, path: &Path) -> Target { Target { kind: LibTarget, - name: name.to_owned(), + name: name.to_strbuf(), path: path.clone() } } @@ -141,7 +141,7 @@ impl Target { pub fn bin_target(name: &str, path: &Path) -> Target { Target { kind: BinTarget, - name: name.to_owned(), + name: name.to_strbuf(), path: path.clone() } } @@ -169,9 +169,9 @@ type TomlExecTarget = TomlTarget; #[deriving(Decodable,Encodable,Eq,Clone,Show)] pub struct Project { - pub name: ~str, - pub version: ~str, - pub authors: ~[~str] + pub name: StrBuf, + pub version: StrBuf, + pub authors: Vec } /* @@ -183,7 +183,7 @@ pub struct TomlManifest { project: Box, lib: Option<~[TomlLibTarget]>, bin: Option<~[TomlExecTarget]>, - dependencies: Option> + dependencies: Option> } impl TomlManifest { @@ -200,7 +200,7 @@ impl TomlManifest { match self.dependencies { Some(ref dependencies) => { for (n, v) in dependencies.iter() { - deps.push(try!(Dependency::parse(*n, *v))); + deps.push(try!(Dependency::parse(n.as_slice(), v.as_slice()))); } } None => () @@ -220,27 +220,27 @@ impl TomlManifest { impl Project { fn to_name_ver(&self) -> NameVer { - NameVer::new(self.name, self.version) + NameVer::new(self.name.as_slice(), self.version.as_slice()) } } #[deriving(Decodable,Encodable,Eq,Clone)] struct TomlTarget { - name: ~str, - path: Option<~str> + name: StrBuf, + path: Option } fn normalize(lib: &Option<~[TomlLibTarget]>, bin: &Option<~[TomlExecTarget]>) -> Vec { fn lib_targets(dst: &mut Vec, libs: &[TomlLibTarget]) { let l = &libs[0]; - let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name)); - dst.push(Target::lib_target(l.name, &Path::new(path))); + let path = l.path.clone().unwrap_or_else(|| format_strbuf!("src/{}.rs", l.name)); + dst.push(Target::lib_target(l.name.as_slice(), &Path::new(path))); } - fn bin_targets(dst: &mut Vec, bins: &[TomlExecTarget], default: |&TomlExecTarget| -> ~str) { + fn bin_targets(dst: &mut Vec, bins: &[TomlExecTarget], default: |&TomlExecTarget| -> StrBuf) { for bin in bins.iter() { let path = bin.path.clone().unwrap_or_else(|| default(bin)); - dst.push(Target::bin_target(bin.name.clone(), &Path::new(path))); + dst.push(Target::bin_target(bin.name.as_slice(), &Path::new(path))); } } @@ -249,13 +249,13 @@ fn normalize(lib: &Option<~[TomlLibTarget]>, bin: &Option<~[TomlExecTarget]>) -> match (lib, bin) { (&Some(ref libs), &Some(ref bins)) => { lib_targets(&mut ret, libs.as_slice()); - bin_targets(&mut ret, bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name)); + bin_targets(&mut ret, bins.as_slice(), |bin| format_strbuf!("src/bin/{}.rs", bin.name)); }, (&Some(ref libs), &None) => { lib_targets(&mut ret, libs.as_slice()); }, (&None, &Some(ref bins)) => { - bin_targets(&mut ret, bins.as_slice(), |bin| format!("src/{}.rs", bin.name)); + bin_targets(&mut ret, bins.as_slice(), |bin| format_strbuf!("src/{}.rs", bin.name)); }, (&None, &None) => () } diff --git a/src/cargo/core/namever.rs b/src/cargo/core/namever.rs index 7f1b13f69..18b975719 100644 --- a/src/cargo/core/namever.rs +++ b/src/cargo/core/namever.rs @@ -10,13 +10,13 @@ use serialize::{ #[deriving(Clone,Eq,Ord)] pub struct NameVer { - name: ~str, + name: StrBuf, version: semver::Version } impl NameVer { pub fn new(name: &str, version: &str) -> NameVer { - NameVer { name: name.to_owned(), version: semver::parse(version.to_owned()).unwrap() } + NameVer { name: name.to_strbuf(), version: semver::parse(version.to_owned()).unwrap() } } pub fn get_name<'a>(&'a self) -> &'a str { @@ -30,19 +30,19 @@ impl NameVer { impl Show for NameVer { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "{} v{}", self.name, self.version) + write!(f, "{} v{}", self.name, self.version) } } impl> Decodable for NameVer { fn decode(d: &mut D) -> Result { - let vector: Vec<~str> = try!(Decodable::decode(d)); - Ok(NameVer { name: vector.get(0).clone(), version: semver::parse(vector.get(1).clone()).unwrap() }) + let vector: Vec = try!(Decodable::decode(d)); + Ok(NameVer { name: vector.get(0).clone(), version: semver::parse(vector.get(1).as_slice()).unwrap() }) } } impl> Encodable for NameVer { fn encode(&self, e: &mut S) -> Result<(), E> { - (vec!(self.name.clone(), self.version.to_str())).encode(e) + (vec!(self.name.clone(), format_strbuf!("{}", self.version))).encode(e) } } diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index 4e1834679..25174c5b1 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -26,7 +26,7 @@ struct SerializedPackage { name: ~str, version: ~str, dependencies: Vec, - authors: Vec<~str>, + authors: Vec, targets: Vec, root: ~str } @@ -95,7 +95,7 @@ impl Package { impl Show for Package { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "{}", self.get_summary().get_name_ver()) + write!(f, "{}", self.get_summary().get_name_ver()) } } diff --git a/src/cargo/core/version_req.rs b/src/cargo/core/version_req.rs index 11739a0c5..8dfb49ff2 100644 --- a/src/cargo/core/version_req.rs +++ b/src/cargo/core/version_req.rs @@ -420,15 +420,15 @@ fn is_sigil(c: char) -> bool { impl fmt::Show for VersionReq { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { if self.predicates.is_empty() { - try!(write!(fmt.buf, "*")); + try!(write!(fmt, "*")); } else { for (i, ref pred) in self.predicates.iter().enumerate() { if i == 0 { - try!(write!(fmt.buf, "{}", pred)); + try!(write!(fmt, "{}", pred)); } else { - try!(write!(fmt.buf, ", {}", pred)); + try!(write!(fmt, ", {}", pred)); } } } @@ -439,15 +439,15 @@ impl fmt::Show for VersionReq { impl fmt::Show for Predicate { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(write!(fmt.buf, "{} {}", self.op, self.major)); + try!(write!(fmt, "{} {}", self.op, self.major)); match self.minor { - Some(v) => try!(write!(fmt.buf, ".{}", v)), + Some(v) => try!(write!(fmt, ".{}", v)), None => () } match self.patch { - Some(v) => try!(write!(fmt.buf, ".{}", v)), + Some(v) => try!(write!(fmt, ".{}", v)), None => () } @@ -458,11 +458,11 @@ impl fmt::Show for Predicate { impl fmt::Show for Op { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - Ex => try!(write!(fmt.buf, "=")), - Gt => try!(write!(fmt.buf, ">")), - GtEq => try!(write!(fmt.buf, ">=")), - Lt => try!(write!(fmt.buf, "<")), - LtEq => try!(write!(fmt.buf, "<=")) + Ex => try!(write!(fmt, "=")), + Gt => try!(write!(fmt, ">")), + GtEq => try!(write!(fmt, ">=")), + Lt => try!(write!(fmt, "<")), + LtEq => try!(write!(fmt, "<=")) } Ok(()) } diff --git a/src/cargo/lib.rs b/src/cargo/lib.rs index aaaa7f60e..44d26a9ac 100644 --- a/src/cargo/lib.rs +++ b/src/cargo/lib.rs @@ -68,7 +68,7 @@ pub fn process_executed<'a, T: Encodable, io::IoError>>(result Err(e) => handle_error(e), Ok(encodable) => { encodable.map(|encodable| { - let encoded: ~str = json::Encoder::str_encode(&encodable); + let encoded = json::Encoder::str_encode(&encodable); println!("{}", encoded); }); } @@ -83,8 +83,12 @@ pub fn handle_error(err: CLIError) { std::os::set_exit_status(exit_code as int); } +fn args() -> Vec { + std::os::args().iter().map(|a| a.to_strbuf()).collect() +} + fn flags_from_args() -> CLIResult { - let mut decoder = FlagDecoder::new::(std::os::args().tail()); + let mut decoder = FlagDecoder::new::(args().tail()); Decodable::decode(&mut decoder).to_result(|e: HammerError| CLIError::new(e.message, None, 1)) } diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs index 919a6b90b..4febf1f78 100644 --- a/src/cargo/ops/cargo_compile.rs +++ b/src/cargo/ops/cargo_compile.rs @@ -29,7 +29,7 @@ pub fn compile(manifest_path: &str) -> CargoResult<()> { let configs = try!(config::all_configs(os::getcwd())); - let config_paths = configs.find(&("paths".to_owned())).map(|v| v.clone()).unwrap_or_else(|| ConfigValue::new()); + let config_paths = configs.find(&"paths".to_strbuf()).map(|v| v.clone()).unwrap_or_else(|| ConfigValue::new()); let mut paths: Vec = match config_paths.get_value() { &config::String(_) => return Err(other_error("The path was configured as a String instead of a List")), diff --git a/src/cargo/ops/cargo_rustc.rs b/src/cargo/ops/cargo_rustc.rs index ab9e7acab..53344a284 100644 --- a/src/cargo/ops/cargo_rustc.rs +++ b/src/cargo/ops/cargo_rustc.rs @@ -7,7 +7,7 @@ use util; use util::{other_error,human_error,CargoResult,CargoError,ProcessBuilder}; use util::result::ProcessError; -type Args = Vec<~str>; +type Args = Vec; pub fn compile(pkgs: &core::PackageSet) -> CargoResult<()> { let mut sorted = match pkgs.sort() { @@ -52,7 +52,7 @@ fn rustc(root: &Path, target: &core::Target, dest: &Path, deps: &[core::Packa let rustc = prepare_rustc(root, target, dest, deps); try!(exec(&rustc) - .map_err(|err| rustc_to_cargo_err(rustc.get_args(), root, err))); + .map_err(|err| rustc_to_cargo_err(rustc.get_args().as_slice(), root, err))); Ok(()) } @@ -69,23 +69,23 @@ fn prepare_rustc(root: &Path, target: &core::Target, dest: &Path, deps: &[core:: } fn build_base_args(into: &mut Args, target: &core::Target, dest: &Path) { - into.push(target.get_path().as_str().unwrap().to_owned()); - into.push("--crate-type".to_owned()); - into.push(target.rustc_crate_type().to_owned()); - into.push("--out-dir".to_owned()); - into.push(dest.as_str().unwrap().to_owned()); + into.push(target.get_path().as_str().unwrap().to_strbuf()); + into.push("--crate-type".to_strbuf()); + into.push(target.rustc_crate_type().to_strbuf()); + into.push("--out-dir".to_strbuf()); + into.push(dest.as_str().unwrap().to_strbuf()); } fn build_deps_args(dst: &mut Args, deps: &[core::Package]) { for dep in deps.iter() { let dir = dep.get_absolute_target_dir(); - dst.push("-L".to_owned()); - dst.push(dir.as_str().unwrap().to_owned()); + dst.push("-L".to_strbuf()); + dst.push(dir.as_str().unwrap().to_strbuf()); } } -fn rustc_to_cargo_err(args: &[~str], cwd: &Path, err: CargoError) -> CargoError { +fn rustc_to_cargo_err(args: &[StrBuf], cwd: &Path, err: CargoError) -> CargoError { let msg = { let output = match err { CargoError { kind: ProcessError(_, ref output), .. } => output, diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs index 3a8737ce5..14266f2c0 100644 --- a/src/cargo/sources/path.rs +++ b/src/cargo/sources/path.rs @@ -17,7 +17,7 @@ impl PathSource { impl Show for PathSource { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f.buf, "the paths source") + write!(f, "the paths source") } } diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs index 3b0343a26..83bf2f342 100644 --- a/src/cargo/util/config.rs +++ b/src/cargo/util/config.rs @@ -12,15 +12,15 @@ pub enum Location { #[deriving(Eq,TotalEq,Clone,Decodable)] pub enum ConfigValueValue { - String(~str), - List(Vec<~str>) + String(StrBuf), + List(Vec) } impl fmt::Show for ConfigValueValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - &String(ref string) => write!(f.buf, "{}", string), - &List(ref list) => write!(f.buf, "{}", list) + &String(ref string) => write!(f, "{}", string), + &List(ref list) => write!(f, "{}", list) } } } @@ -68,8 +68,8 @@ impl> Encodable for ConfigValue { impl fmt::Show for ConfigValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let paths: Vec<~str> = self.path.iter().map(|p| p.display().to_str()).collect(); - write!(f.buf, "{} (from {})", self.value, paths) + let paths: Vec = self.path.iter().map(|p| format_strbuf!("{}", p.display())).collect(); + write!(f, "{} (from {})", self.value, paths) } } @@ -78,7 +78,7 @@ pub fn get_config(pwd: Path, key: &str) -> CargoResult { .map_err(|_| other_error("config key not found").with_detail(format!("key={}", key))) } -pub fn all_configs(pwd: Path) -> CargoResult> { +pub fn all_configs(pwd: Path) -> CargoResult> { let mut map = HashMap::new(); try!(walk_tree(&pwd, |file| { @@ -89,7 +89,7 @@ pub fn all_configs(pwd: Path) -> CargoResult> { } #[allow(unused_variable)] -pub fn set_config(key: ~str, value: ~str, location: Location) -> CargoResult<()> { +pub fn set_config(key: StrBuf, value: StrBuf, location: Location) -> CargoResult<()> { Ok(()) } @@ -140,15 +140,15 @@ fn extract_config(file: io::fs::File, key: &str) -> CargoResult { let val = try!(root.lookup(key).require(other_error(""))); let v = match val { - &toml::String(ref val) => String(val.to_owned()), - &toml::Array(ref val) => List(val.iter().map(|s: &toml::Value| s.to_str()).collect()), + &toml::String(ref val) => String(val.clone()), + &toml::Array(ref val) => List(val.iter().map(|s: &toml::Value| format_strbuf!("{}", s)).collect()), _ => return Err(other_error("")) }; Ok(ConfigValue{ value: v, path: vec!(path) }) } -fn extract_all_configs(file: io::fs::File, map: &mut HashMap<~str, ConfigValue>) -> CargoResult<()> { +fn extract_all_configs(file: io::fs::File, map: &mut HashMap) -> CargoResult<()> { let path = file.path().clone(); let mut buf = io::BufferedReader::new(file); let root = try!(toml::parse_from_buffer(&mut buf).map_err(|err| @@ -159,9 +159,9 @@ fn extract_all_configs(file: io::fs::File, map: &mut HashMap<~str, ConfigValue>) for (key, value) in table.iter() { match value { - &toml::String(ref val) => { map.insert(key.to_owned(), ConfigValue { value: String(val.to_owned()), path: vec!(path.clone()) }); } + &toml::String(ref val) => { map.insert(key.clone(), ConfigValue { value: String(val.clone()), path: vec!(path.clone()) }); } &toml::Array(ref val) => { - let config = map.find_or_insert_with(key.to_owned(), |_| { + let config = map.find_or_insert_with(key.clone(), |_| { ConfigValue { path: vec!(), value: List(vec!()) } }); @@ -179,11 +179,11 @@ fn merge_array(existing: &mut ConfigValue, val: &[toml::Value], path: &Path) -> match existing.value { String(_) => return Err(other_error("should be an Array, but it was a String")), List(ref mut list) => { - let new_list: Vec> = val.iter().map(|s: &toml::Value| toml_string(s)).collect(); + let new_list: Vec> = val.iter().map(|s: &toml::Value| toml_string(s)).collect(); if new_list.iter().any(|v| v.is_err()) { return Err(other_error("should be an Array of Strings, but was an Array of other values")); } else { - let new_list: Vec<~str> = new_list.move_iter().map(|v| v.unwrap()).collect(); + let new_list: Vec = new_list.move_iter().map(|v| v.unwrap()).collect(); list.push_all(new_list.as_slice()); existing.path.push(path.clone()); Ok(()) @@ -192,9 +192,9 @@ fn merge_array(existing: &mut ConfigValue, val: &[toml::Value], path: &Path) -> } } -fn toml_string(val: &toml::Value) -> CargoResult<~str> { +fn toml_string(val: &toml::Value) -> CargoResult { match val { - &toml::String(ref str) => Ok(str.to_owned()), + &toml::String(ref str) => Ok(str.clone()), _ => Err(other_error("")) } } diff --git a/src/cargo/util/process_builder.rs b/src/cargo/util/process_builder.rs index e8aea0e0e..5ba79f121 100644 --- a/src/cargo/util/process_builder.rs +++ b/src/cargo/util/process_builder.rs @@ -2,28 +2,28 @@ use std::fmt; use std::fmt::{Show,Formatter}; use std::os; use std::path::Path; -use std::io::process::{Process,ProcessConfig,ProcessOutput,InheritFd}; +use std::io::process::{Command,ProcessOutput,InheritFd}; use util::{CargoResult,io_error,process_error}; use collections::HashMap; #[deriving(Clone,Eq)] pub struct ProcessBuilder { - program: ~str, - args: Vec<~str>, - path: Vec<~str>, - env: HashMap<~str, ~str>, + program: StrBuf, + args: Vec, + path: Vec, + env: HashMap, cwd: Path } impl Show for ProcessBuilder { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - try!(write!(f.buf, "`{}", self.program)); + try!(write!(f, "`{}", self.program)); if self.args.len() > 0 { - try!(write!(f.buf, " {}", self.args.connect(" "))); + try!(write!(f, " {}", self.args.connect(" "))); } - write!(f.buf, "`") + write!(f, "`") } } @@ -31,18 +31,18 @@ impl Show for ProcessBuilder { static PATH_SEP : &'static str = ":"; impl ProcessBuilder { - pub fn args(mut self, arguments: &[~str]) -> ProcessBuilder { + pub fn args(mut self, arguments: &[StrBuf]) -> ProcessBuilder { self.args = Vec::from_slice(arguments); self } - pub fn get_args<'a>(&'a self) -> &'a [~str] { + pub fn get_args<'a>(&'a self) -> &'a [StrBuf] { self.args.as_slice() } pub fn extra_path(mut self, path: Path) -> ProcessBuilder { // For now, just convert to a string, but we should do something better - self.path.push(format!("{}", path.display())); + self.path.push(format_strbuf!("{}", path.display())); self } @@ -53,16 +53,13 @@ impl ProcessBuilder { // TODO: should InheritFd be hardcoded? pub fn exec(&self) -> CargoResult<()> { - let mut config = try!(self.build_config()); - let env = self.build_env(); + let mut command = self.build_command(); + command + .env(self.build_env()) + .stdout(InheritFd(1)) + .stderr(InheritFd(2)); - // Set where the output goes - config.env = Some(env.as_slice()); - config.stdout = InheritFd(1); - config.stderr = InheritFd(2); - - let mut process = try!(Process::configure(config).map_err(io_error)); - let exit = process.wait(); + let exit = try!(command.status().map_err(io_error)); if exit.success() { Ok(()) @@ -73,12 +70,10 @@ impl ProcessBuilder { } pub fn exec_with_output(&self) -> CargoResult { - let mut config = try!(self.build_config()); - let env = self.build_env(); - - config.env = Some(env.as_slice()); + let mut command = self.build_command(); + command.env(self.build_env()); - let output = try!(Process::configure(config).map(|mut ok| ok.wait_with_output()).map_err(io_error)); + let output = try!(command.output().map_err(io_error)); if output.status.success() { Ok(output) @@ -88,21 +83,17 @@ impl ProcessBuilder { } } - fn build_config<'a>(&'a self) -> CargoResult> { - let mut config = ProcessConfig::new(); - - config.program = self.program.as_slice(); - config.args = self.args.as_slice(); - config.cwd = Some(&self.cwd); - - Ok(config) + fn build_command(&self) -> Command { + let mut command = Command::new(self.program.as_slice()); + command.args(self.args.as_slice()).cwd(&self.cwd); + command } - fn debug_string(&self) -> ~str { - format!("{} {}", self.program, self.args.connect(" ")) + fn debug_string(&self) -> StrBuf { + format_strbuf!("{} {}", self.program, self.args.connect(" ")) } - fn build_env(&self) -> ~[(~str, ~str)] { + fn build_env(&self) -> ~[(StrBuf, StrBuf)] { let mut ret = Vec::new(); for (key, val) in self.env.iter() { @@ -113,31 +104,29 @@ impl ProcessBuilder { } match self.build_path() { - Some(path) => ret.push(("PATH".to_owned(), path)), + Some(path) => ret.push(("PATH".to_strbuf(), path)), _ => () } ret.as_slice().to_owned() } - fn build_path(&self) -> Option<~str> { + fn build_path(&self) -> Option { let path = self.path.connect(PATH_SEP); match self.env.find_equiv(&("PATH")) { Some(existing) => { if self.path.is_empty() { - Some(existing.to_owned()) + Some(existing.clone()) + } else { + Some(format_strbuf!("{}{}{}", existing, PATH_SEP, path)) } - else { - Some(existing.as_slice() + PATH_SEP + path) - } - } + }, None => { if self.path.is_empty() { None - } - else { - Some(path) + } else { + Some(path.to_strbuf()) } } } @@ -146,7 +135,7 @@ impl ProcessBuilder { pub fn process(cmd: &str) -> ProcessBuilder { ProcessBuilder { - program: cmd.to_owned(), + program: cmd.to_strbuf(), args: vec!(), path: vec!(), cwd: os::getcwd(), @@ -154,11 +143,11 @@ pub fn process(cmd: &str) -> ProcessBuilder { } } -fn system_env() -> HashMap<~str, ~str> { +fn system_env() -> HashMap { let mut ret = HashMap::new(); for &(ref key, ref val) in os::env().iter() { - ret.insert(key.clone(), val.clone()); + ret.insert(key.to_strbuf(), val.to_strbuf()); } ret diff --git a/src/cargo/util/result.rs b/src/cargo/util/result.rs index 1692e1ab8..c57562fa5 100644 --- a/src/cargo/util/result.rs +++ b/src/cargo/util/result.rs @@ -121,12 +121,12 @@ pub enum CargoErrorKind { impl Show for CargoErrorKind { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - &ProcessError(ref exit, _) => write!(f.buf, "ProcessError({})", exit), - &HumanReadableError => write!(f.buf, "HumanReadableError"), - &InternalError => write!(f.buf, "InternalError"), - &IoError(ref err) => write!(f.buf, "IoError({})", err), - &TomlError(ref err) => write!(f.buf, "TomlError({})", err), - &OtherCargoError => write!(f.buf, "OtherCargoError") + &ProcessError(ref exit, _) => write!(f, "ProcessError({})", exit), + &HumanReadableError => write!(f, "HumanReadableError"), + &InternalError => write!(f, "InternalError"), + &IoError(ref err) => write!(f, "IoError({})", err), + &TomlError(ref err) => write!(f, "TomlError({})", err), + &OtherCargoError => write!(f, "OtherCargoError") } } } -- 2.30.2